Communication networks allow computing devices to communicate with one another. A computer at one location, for instance, can send data to and receive data from a computer at another location, if the two computers are communicatively coupled to a network. Networks of this type include wired and wireless networks, Ethernet-type networks, intranets, extranets, the Internet, and/or telephony networks, among other types of networks.
Many types of networks are packet-driven, or packetized, networks. Such networks allow data to be communicated thereover by having a data packet split into a number of different packet fragments, which are smaller packets of data that actually traverse the network. For instance, 2,000 bytes of data within a data packet may be split over four packet fragments, each containing 500 bytes of the data. The data packet is typically assigned an identifier, where each of the packet fragments into which the data packet has been segmented is also assigned this same identifier. If the packet fragments are received out of order, they are reordered by the receiving device. Some such types of networks include Internet Protocol (IP) networks, including Transmission Control Protocol (TCP)/IP networks and User Datagram Protocol (UDP)/IP networks, among others.
A difficulty with such packetized networks arises when a packet fragment is lost, and a subsequently received packet fragment is presumed to be the lost packet. For example, four packet fragments may be sent from a first computer to a second computer, each containing 500 bytes of data. The packet fragments are assigned the identifier of their parent data packet. At the second computer, the first, second, and fourth packet fragments may be received, but the third packet fragment may have been lost when being transmitted over the network.
The second computer will wait for a predetermined length of time for this packet fragment before signaling to the first computer that it was not received, and that the first computer should resend it. While the second computer is waiting for the packet fragment, however, a different packet fragment with the same identifier may be received. Therefore, the second computer believes that this different packet fragment is the packet fragment it has been waiting for. However, because the packet fragment only coincidentally has the same identifier as the lost packet fragment, the second computer actually does not have the correct packet fragment, and will not properly reassemble the data packet.
This problem arises especially in situations where large amounts of data are being sent from one computer to another computer over a fast network. The identifiers assigned to data packets may be sixteen bits in length. Therefore, each identifier is a hexadecimal number within the range 0x0000 through 0xFFFF. A first data packet, and its packet fragments, may be assigned the identifier 0x0000, the second packet and its fragments may be assigned the identifier 0x0001, the third packet and its fragments may be assigned the identifier 0x0002, and so on, in order. Once the identifier 0xFFFF has been assigned to a data packet, the identifiers “roll over”—that is, data packets and their packet fragments are assigned identifiers beginning with 0x0000 again.
Therefore, the problem that has been described can occur in the following situation. Data packets and their packet fragments to be sent to a computer are assigned identifiers 0x0000, 0x0001, and 0x0002, for instance. The computer receives all the packet fragments for the data packets assigned identifiers 0x0000 and 0x0001, but does not receive all the packet fragments for the data packet assigned identifier 0x0002. The computer waits a predetermined length of time before requesting that the packet fragment or fragments in question be resent.
However, while the computer is waiting this length of time, further packet fragments of other data packets are sent to the computer, where the data packets and their packet fragments are assigned identifiers through 0xFFFF, such that the identifiers roll over. The computer again begins to receive the new packet fragments of these new packets that have been assigned identifiers starting with 0x0000, such that the computer receives new packet fragments having the identifier 0x0002. These new packet fragments, however, are different than the packet fragments that the computer is waiting for, in that they are associated with a different data packet having the same identifier 0x0002. That is, the packet fragment or fragments that the computer is waiting for are related to a different packet having the identifier 0x0002 than the data packet having the identifier 0x0002 to which the new packet fragments that have been received are related. Because the new packet fragments also have the identifier 0x0002, however, the computer may conclude that it has received the packet fragments that it has been waiting for, when in fact it has not. Data packets will therefore be assembled from incorrect packet fragments.
One way to prevent this problem is to include a checksum value for a data packet that is being segmented into a number of packets fragments to be sent to a computer over a network. A checksum value is a value used to ensure data are stored or transmitted without error. It is created by calculating the binary values in a block of data according to an algorithm and storing the results with the data. When the data is received by the computer over the network, a new checksum is determined and matched against the existing checksum. A non-match indicates an error, such that the data was not properly received.
For instance, 1,500 bytes of data within a data packet may be sent to a computer, with the data packet having a specific identifier, and the data packet being segmented into three packet fragments. In one of these three fragments, a checksum value CV1 is included for the entire data packet. When the computer receives all the packet fragments, it computes its own checksum value CV2 based on the data packet assembled from the packet fragments. If the checksum value CV2 does not match the checksum value CV1, then the computer concludes that it has not received the data packet correctly, and requests that the data packet be resent.
For example, the second packet fragment may have been lost during transmission over the network, where the computer did receive the first and the third packet fragments, and did receive the checksum value CV1. While the computer is waiting for the second packet fragment, it may receive another, different packet fragment with the same data packet identifier, because the packet identifiers have rolled over as has been described. The computer assembles the data from the correct first and third packet fragments, and from the incorrect second packet fragment coincidentally having the same identifier, and computes a checksum value CV2. Since the second packet fragment is not the correct packet fragment, however, in all likelihood the checksum value CV2 will not match the checksum value CV1. Therefore, the computer can conclude that it has not received the 1,500 bytes of data correctly.
However, the checksum value itself may be a limited-length value, such as sixteen bits in length. This means that even if the incorrect packet fragment is received with the correct identifier, there is still nevertheless a one in 216=65,536 chance that the determined checksum value CV2 will match the checksum value CV1. Thus, a small chance remains that the computer will conclude that it has received the data packet correctly when in fact it has not. Therefore, even using checksum values does not ensure that this identifier-rollover problem can be detected. Although using a longer-length checksum value decreases the odds that the problem will occur, there is a practical limit as to how many bits in length checksum values can be. Furthermore, the odds that the problem will occur will never decrease completely to zero, such that regardless of the number of bits of the checksum value, the problem can still occur.
For these and other reasons, therefore, there is a need for the present invention.